home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / a_utils / yacc / byacc / byacc.lha / test / error.tab.c < prev    next >
C/C++ Source or Header  |  1993-02-22  |  7KB  |  276 lines
  1. #ifndef lint
  2. static char yysccsid[] = "@(#)yaccpar    1.9 (Berkeley) 02/21/93";
  3. #endif
  4. #define YYBYACC 1
  5. #define YYMAJOR 1
  6. #define YYMINOR 9
  7. #define yyclearin (yychar=(-1))
  8. #define yyerrok (yyerrflag=0)
  9. #define YYRECOVERING (yyerrflag!=0)
  10. #define YYPREFIX "yy"
  11. #define YYERRCODE 256
  12. short yylhs[] = {                                        -1,
  13.     0,
  14. };
  15. short yylen[] = {                                         2,
  16.     1,
  17. };
  18. short yydefred[] = {                                      0,
  19.     1,    0,
  20. };
  21. short yydgoto[] = {                                       2,
  22. };
  23. short yysindex[] = {                                   -256,
  24.     0,    0,
  25. };
  26. short yyrindex[] = {                                      0,
  27.     0,    0,
  28. };
  29. short yygindex[] = {                                      0,
  30. };
  31. #define YYTABLESIZE 0
  32. short yytable[] = {                                       1,
  33. };
  34. short yycheck[] = {                                     256,
  35. };
  36. #define YYFINAL 2
  37. #ifndef YYDEBUG
  38. #define YYDEBUG 0
  39. #endif
  40. #define YYMAXTOKEN 0
  41. #if YYDEBUG
  42. char *yyname[] = {
  43. "end-of-file",
  44. };
  45. char *yyrule[] = {
  46. "$accept : S",
  47. "S : error",
  48. };
  49. #endif
  50. #ifndef YYSTYPE
  51. typedef int YYSTYPE;
  52. #endif
  53. #ifdef YYSTACKSIZE
  54. #undef YYMAXDEPTH
  55. #define YYMAXDEPTH YYSTACKSIZE
  56. #else
  57. #ifdef YYMAXDEPTH
  58. #define YYSTACKSIZE YYMAXDEPTH
  59. #else
  60. #define YYSTACKSIZE 500
  61. #define YYMAXDEPTH 500
  62. #endif
  63. #endif
  64. int yydebug;
  65. int yynerrs;
  66. int yyerrflag;
  67. int yychar;
  68. short *yyssp;
  69. YYSTYPE *yyvsp;
  70. YYSTYPE yyval;
  71. YYSTYPE yylval;
  72. short yyss[YYSTACKSIZE];
  73. YYSTYPE yyvs[YYSTACKSIZE];
  74. #define yystacksize YYSTACKSIZE
  75. #line 4 "error.y"
  76. main(){printf("yyparse() = %d\n",yyparse());}
  77. yylex(){return-1;}
  78. yyerror(s)char*s;{printf("%s\n",s);}
  79. #line 80 "error.tab.c"
  80. #define YYABORT goto yyabort
  81. #define YYREJECT goto yyabort
  82. #define YYACCEPT goto yyaccept
  83. #define YYERROR goto yyerrlab
  84. int
  85. yyparse()
  86. {
  87.     register int yym, yyn, yystate;
  88. #if YYDEBUG
  89.     register char *yys;
  90.     extern char *getenv();
  91.  
  92.     if (yys = getenv("YYDEBUG"))
  93.     {
  94.         yyn = *yys;
  95.         if (yyn >= '0' && yyn <= '9')
  96.             yydebug = yyn - '0';
  97.     }
  98. #endif
  99.  
  100.     yynerrs = 0;
  101.     yyerrflag = 0;
  102.     yychar = (-1);
  103.  
  104.     yyssp = yyss;
  105.     yyvsp = yyvs;
  106.     *yyssp = yystate = 0;
  107.  
  108. yyloop:
  109.     if (yyn = yydefred[yystate]) goto yyreduce;
  110.     if (yychar < 0)
  111.     {
  112.         if ((yychar = yylex()) < 0) yychar = 0;
  113. #if YYDEBUG
  114.         if (yydebug)
  115.         {
  116.             yys = 0;
  117.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  118.             if (!yys) yys = "illegal-symbol";
  119.             printf("%sdebug: state %d, reading %d (%s)\n",
  120.                     YYPREFIX, yystate, yychar, yys);
  121.         }
  122. #endif
  123.     }
  124.     if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
  125.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  126.     {
  127. #if YYDEBUG
  128.         if (yydebug)
  129.             printf("%sdebug: state %d, shifting to state %d\n",
  130.                     YYPREFIX, yystate, yytable[yyn]);
  131. #endif
  132.         if (yyssp >= yyss + yystacksize - 1)
  133.         {
  134.             goto yyoverflow;
  135.         }
  136.         *++yyssp = yystate = yytable[yyn];
  137.         *++yyvsp = yylval;
  138.         yychar = (-1);
  139.         if (yyerrflag > 0)  --yyerrflag;
  140.         goto yyloop;
  141.     }
  142.     if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
  143.             yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
  144.     {
  145.         yyn = yytable[yyn];
  146.         goto yyreduce;
  147.     }
  148.     if (yyerrflag) goto yyinrecovery;
  149. #ifdef lint
  150.     goto yynewerror;
  151. #endif
  152. yynewerror:
  153.     yyerror("syntax error");
  154. #ifdef lint
  155.     goto yyerrlab;
  156. #endif
  157. yyerrlab:
  158.     ++yynerrs;
  159. yyinrecovery:
  160.     if (yyerrflag < 3)
  161.     {
  162.         yyerrflag = 3;
  163.         for (;;)
  164.         {
  165.             if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
  166.                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
  167.             {
  168. #if YYDEBUG
  169.                 if (yydebug)
  170.                     printf("%sdebug: state %d, error recovery shifting\
  171.  to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
  172. #endif
  173.                 if (yyssp >= yyss + yystacksize - 1)
  174.                 {
  175.                     goto yyoverflow;
  176.                 }
  177.                 *++yyssp = yystate = yytable[yyn];
  178.                 *++yyvsp = yylval;
  179.                 goto yyloop;
  180.             }
  181.             else
  182.             {
  183. #if YYDEBUG
  184.                 if (yydebug)
  185.                     printf("%sdebug: error recovery discarding state %d\n",
  186.                             YYPREFIX, *yyssp);
  187. #endif
  188.                 if (yyssp <= yyss) goto yyabort;
  189.                 --yyssp;
  190.                 --yyvsp;
  191.             }
  192.         }
  193.     }
  194.     else
  195.     {
  196.         if (yychar == 0) goto yyabort;
  197. #if YYDEBUG
  198.         if (yydebug)
  199.         {
  200.             yys = 0;
  201.             if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  202.             if (!yys) yys = "illegal-symbol";
  203.             printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
  204.                     YYPREFIX, yystate, yychar, yys);
  205.         }
  206. #endif
  207.         yychar = (-1);
  208.         goto yyloop;
  209.     }
  210. yyreduce:
  211. #if YYDEBUG
  212.     if (yydebug)
  213.         printf("%sdebug: state %d, reducing by rule %d (%s)\n",
  214.                 YYPREFIX, yystate, yyn, yyrule[yyn]);
  215. #endif
  216.     yym = yylen[yyn];
  217.     yyval = yyvsp[1-yym];
  218.     switch (yyn)
  219.     {
  220.     }
  221.     yyssp -= yym;
  222.     yystate = *yyssp;
  223.     yyvsp -= yym;
  224.     yym = yylhs[yyn];
  225.     if (yystate == 0 && yym == 0)
  226.     {
  227. #if YYDEBUG
  228.         if (yydebug)
  229.             printf("%sdebug: after reduction, shifting from state 0 to\
  230.  state %d\n", YYPREFIX, YYFINAL);
  231. #endif
  232.         yystate = YYFINAL;
  233.         *++yyssp = YYFINAL;
  234.         *++yyvsp = yyval;
  235.         if (yychar < 0)
  236.         {
  237.             if ((yychar = yylex()) < 0) yychar = 0;
  238. #if YYDEBUG
  239.             if (yydebug)
  240.             {
  241.                 yys = 0;
  242.                 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
  243.                 if (!yys) yys = "illegal-symbol";
  244.                 printf("%sdebug: state %d, reading %d (%s)\n",
  245.                         YYPREFIX, YYFINAL, yychar, yys);
  246.             }
  247. #endif
  248.         }
  249.         if (yychar == 0) goto yyaccept;
  250.         goto yyloop;
  251.     }
  252.     if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
  253.             yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
  254.         yystate = yytable[yyn];
  255.     else
  256.         yystate = yydgoto[yym];
  257. #if YYDEBUG
  258.     if (yydebug)
  259.         printf("%sdebug: after reduction, shifting from state %d \
  260. to state %d\n", YYPREFIX, *yyssp, yystate);
  261. #endif
  262.     if (yyssp >= yyss + yystacksize - 1)
  263.     {
  264.         goto yyoverflow;
  265.     }
  266.     *++yyssp = yystate;
  267.     *++yyvsp = yyval;
  268.     goto yyloop;
  269. yyoverflow:
  270.     yyerror("yacc stack overflow");
  271. yyabort:
  272.     return (1);
  273. yyaccept:
  274.     return (0);
  275. }
  276.